home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / COMM / MSKRMSRC.ARJ / MSNTNI.ASM < prev    next >
Assembly Source File  |  1991-10-24  |  18KB  |  707 lines
  1.     NAME    MSNTNI
  2. ; File MSNTNI.ASM
  3. ; Telnet interface to MS-DOS Kermit
  4. ;
  5. ; Copyright (C) 1991, Trustees of Columbia University in the
  6. ;  City of New York.  Permission is granted to any individual or
  7. ;  institution to use, copy, or redistribute this software as long as
  8. ;  it is not sold for profit and this copyright notice is retained.
  9. ; 
  10. ; Written by Joe R. Doupnik, Utah State University, 
  11. ;  jrd@cc.usu.edu, jrd@usu.Bitnet.
  12. ;
  13. ; Edit history
  14. ; 6 Sept 1991 version 3.11
  15. ; Last edit 16 Sept 1991
  16.     include    mssdef.h
  17.  
  18. getintv    equ    35h        ; DOS get interrupt vector to es:bx
  19. bapicon    equ    0a0h        ; 3Com BAPI, connect to port
  20. bapidisc equ    0a1h        ; 3Com BAPI, disconnect
  21. bapiwrit equ    0a4h        ; 3Com BAPI, write block
  22. bapiread equ    0a5h        ; 3Com BAPI, read block
  23. bapibrk    equ    0a6h        ; 3Com BAPI, send short break
  24. bapistat equ    0a7h        ; 3Com BAPI, read status (# chars to be read)
  25. bapihere equ    0afh        ; 3Com BAPI, presence check
  26. bapieecm equ    0b0h        ; 3Com BAPI, enable/disable ECM char
  27. bapiecm    equ    0b1h        ; 3Com BAPI, trap Enter Command Mode char
  28.  
  29. data    segment public 'kdata'
  30.     extrn    tcptos:word    ; top of stack for TCP code
  31.     extrn    flags:byte, yflags:byte, portval:word
  32. data    ends
  33.  
  34. _TEXT    SEGMENT  WORD PUBLIC 'CODE'
  35. _TEXT    ENDS
  36. _DATA    SEGMENT  WORD PUBLIC 'DATA'
  37. _DATA    ENDS
  38. CONST    SEGMENT  WORD PUBLIC 'CONST'
  39. CONST    ENDS
  40. _BSS    SEGMENT  WORD PUBLIC 'BSS'
  41. _BSS    ENDS
  42. DGROUP    GROUP    CONST, _BSS, _DATA
  43.     ASSUME  CS: _TEXT, DS: DGROUP, SS: DGROUP
  44.  
  45. _DATA      SEGMENT
  46.     public _kmyip, _knetmask, _kdomain, _kgateway, _kns1, _kns2, _khost
  47.     public _kbcast, _bapibuf, _bapireq, _bapiret, _msgcnt, _msgbuf
  48.     public    _display_mode
  49.  
  50.     extrn    _my_ip_addr:dword, _sin_mask:dword
  51.  
  52.         db 'DUMMY'           ; null pointer guard
  53. _kmyip        db 33 dup (0)        ; our IP number
  54. _knetmask    db 33 dup (0)        ; our netmask
  55. _kdomain    db 33 dup (0)        ; our domain
  56. _kgateway     db 33 dup (0)        ; our gateway
  57. _kns1        db 33 dup (0)        ; our nameserver #1
  58. _kns2        db 33 dup (0)        ; our nameserver #2
  59. _khost        db 33 dup (0)        ; remote host name/IP #
  60. _kbcast        db 33 dup (0)        ; broadcast IP
  61. _kserver    dw    0        ; non-zero for Kermit server
  62. bpprefix db    'Bootp ',0        ; prefix for Bootp provided IP addr
  63. oldint14 dd    0            ; original Int 14h owner
  64. oldint8    dd    0            ; original Int 8 owner
  65. tcpstack dd    0            ; TCP code stack
  66. stack8    dd    0            ; stack at Int 8 invokation
  67. kstack    dw    0            ; Kermit mainline stack pointer
  68. tempax    dw    0            ; a temp
  69. tcpflag    db    0        ; who is running TCP code: 1=Kermit, 2=Int 8
  70. tcpdata    dw    0            ; Kermit offset of "tcpdata" block
  71. int8cnt    db    0            ; Int 8 times called counter
  72. _display_mode db 0            ; msg, none if == 0
  73. opcode    db    0            ; BAPI op code
  74. userbuf    dd    0            ; BAPI user's comms buffer address
  75. _bapireq dw    0            ; BAPI count of chars requested
  76. _bapiret dw    0            ; BAPI count of chars processed
  77. buflen    equ    512
  78. _bapibuf db    buflen dup (0)        ; BAPI buffer in TCP address space
  79. _msgcnt    dw    0            ; count of bytes in msg buffer
  80. _msgbuf    db    256 dup (0)        ; interrupt level msg buffer
  81. _DATA      ENDS
  82.  
  83.  
  84. _TEXT    segment
  85.     ASSUME  CS: _TEXT, DS: DGROUP, SS: DGROUP
  86.     extrn    _int14handler:near, _main:near, _exit:near, _pkt_release:near
  87.     extrn    _int8tick:near, _bcopy:near, _itoa:near, _strlen:near
  88.     extrn    _strcpy:near
  89.  
  90. public    _enable
  91. enable    proc    near
  92. _enable    equ    this byte
  93.     sti
  94.     ret
  95. enable    endp
  96.  
  97. public    _disable
  98. disable    proc    near
  99. _disable equ    this byte
  100.     cli
  101.     ret
  102. disable    endp
  103.  
  104. ; Hook Interrupts 8h and 14h. Return AX = 1 if successful else 0.
  105.     public    _hookvect
  106. hookvect proc    near
  107. _hookvect equ    this byte
  108.     push    bp
  109.     mov    bp,sp
  110.     mov    ax,bp
  111.     add    ax,2+2            ; C sp just before this call
  112.     mov    word ptr tcpstack,ax    ; save as main prog stack level
  113.     push    es
  114.     mov    ah,getintv        ; get interrupt vector
  115.     mov    al,14h            ; vector number
  116.     int    dos
  117.     mov    ax,es
  118.     mov    cx,cs
  119.     cmp    ax,cx            ; points to us now?
  120.     je    hook1            ; yes, don't touch again
  121.     mov    word ptr DGROUP:oldint14+2,ax    ; save segment
  122.     mov    word ptr DGROUP:oldint14,bx    ; save offset
  123.     mov    dx,offset ourserial     ; new handler
  124.     push    ds
  125.     mov    ax,cs            ; segment
  126.     mov    ds,ax
  127.     mov    al,14h            ; for Int 14h
  128.     mov    ah,25H            ; set interrupt address from ds:dx
  129.     int    dos
  130.     pop    ds
  131.  
  132. hook1:    mov    ah,getintv        ; get interrupt vector
  133.     mov    al,8            ; vector number
  134.     int    dos
  135.     mov    ax,es
  136.     mov    cx,cs
  137.     cmp    ax,cx            ; points to us now?
  138.     je    hook2            ; e = yes, do not touch
  139.     mov    word ptr DGROUP:oldint8+2,ax    ; save segment
  140.     mov    word ptr DGROUP:oldint8,bx    ; save offset
  141.     mov    dx,offset ourtimer     ; new handler
  142.     push    ds
  143.     mov    ax,cs            ; segment
  144.     mov    ds,ax
  145.     mov    al,8            ; for Int 8
  146.     mov    ah,25H            ; set interrupt address from ds:dx
  147.     int    dos
  148.     pop    ds
  149. hook2:    mov    tcpflag,1     ; say Kermit but not Int 8 is running TCP
  150.     mov    ax,1            ; return 1 for success
  151.     pop    es
  152.     pop    bp
  153.     ret
  154. hook3:    call    unhookvect        ; put any back
  155.     xor    ax,ax            ; return 0 for failure
  156.     pop    es
  157.     pop    bp
  158.     ret
  159. hookvect endp
  160.  
  161.     public    _unhookvect
  162. unhookvect proc    near
  163. _unhookvect equ    this byte
  164.     push    bp
  165.     mov    bp,sp
  166.     push    es
  167.     push    bx
  168.     push    cx
  169.     clc
  170.     mov    tempax,0        ; assume failure status
  171.     mov    ah,getintv        ; get interrupt vector
  172.     mov    al,14h            ; vector number
  173.     int    dos
  174.     jc    unhook1            ; c = failed
  175.     mov    ax,es            ; es:bx is current owner, us?
  176.     mov    cx,cs
  177.     cmp    ax,cx            ; seg should be right here
  178.     jne    unhook1            ; ne = is not
  179.     cmp    bx,offset ourserial    ; should be the same too
  180.     jne    unhook1            ; ne = is not, let them have the int
  181.     mov    ax,word ptr DGROUP:oldint14+2    ; segment
  182.     mov    dx,word ptr DGROUP:oldint14    ; offset
  183.     mov    cx,dx
  184.     or    cx,ax            ; was it used by us?
  185.     jz    unhook1            ; z = no, leave alone
  186.     push    ds
  187.     mov    ds,ax
  188.     mov    al,14h            ; for Int 14h
  189.     mov    ah,25H            ; set interrupt address from ds:dx
  190.     int    dos
  191.     pop    ds
  192.     mov    word ptr DGROUP:oldint14,0
  193.     mov    word ptr DGROUP:oldint14+2,0
  194.     mov    tempax,1        ; success so far
  195.  
  196. unhook1:mov    ah,getintv        ; get interrupt vector
  197.     clc
  198.     mov    al,8            ; vector number
  199.     int    dos
  200.     jc    unhook2            ; c = failed
  201.     mov    ax,es            ; es:bx is current owner, us?
  202.     mov    cx,cs
  203.     cmp    ax,cx            ; seg should be right here
  204.     jne    unhook2            ; ne = is not
  205.     cmp    bx,offset ourtimer    ; should be the same too
  206.     jne    unhook2            ; ne = is not, let them have the int
  207.     mov    ax,word ptr DGROUP:oldint8+2    ; segment
  208.     mov    dx,word ptr DGROUP:oldint8    ; offset
  209.     mov    cx,dx
  210.     or    cx,ax            ; was it used by us?
  211.     jz    unhook2            ; z = no, leave alone
  212.     push    ds
  213.     mov    ds,ax
  214.     mov    al,8            ; for Int 8
  215.     mov    ah,25H            ; set interrupt address from ds:dx
  216.     int    dos
  217.     pop    ds
  218.     and    tcpflag,not 2        ; Int 8 no longer touches TCP
  219.     mov    word ptr DGROUP:oldint8,0
  220.     mov    word ptr DGROUP:oldint8+2,0
  221.     mov    tempax,1        ; success status
  222.     jmp    short unhook3
  223. unhook2:mov    tempax,0        ; failure
  224. unhook3:mov    ax,tempax        ; return status (1=success, 0=fail)
  225.     pop    cx
  226.     pop    bx
  227.     pop    es
  228.     pop    bp
  229.     ret
  230. unhookvect endp
  231.  
  232. ; Int 8 routine to call the TCP code if Kermit does not.
  233. ourtimer proc near
  234.     push    ds
  235.     push    ax
  236.     mov    ax,dgroup        ; set addressibility to our dgroup
  237.     mov    ds,ax
  238.     pushf                ; simulate interrupt invokation
  239.     call    dword ptr DGROUP:oldint8 ; call previous owner of Int 8
  240.  
  241.     mov    ax,dgroup
  242.     mov    ds,ax
  243.     test    tcpflag,1+2        ; is TCP code running now?
  244.     jnz    ourtim2            ; nz = yes, so we don't run now
  245.     mov    al,int8cnt        ; get our times called counter
  246.     inc    al            ; up once again
  247.     and    al,7            ; keep 3 bits, about .5 sec @18.2tic/s
  248.     mov    int8cnt,al        ; store
  249.     or    al,al            ; is it zero?
  250.     jnz    ourtim2            ; nz = no, go away for awhile
  251.     or    tcpflag,2        ; say we are running the TCP code
  252.     push    bp
  253.     push    bx
  254.     push    cx
  255.     push    dx
  256.     push    si
  257.     push    di
  258.     push    es
  259.     mov    ax,dgroup        ; set addressibility to our dgroup
  260.     mov    ds,ax
  261.     cli
  262.     mov    ax,ss
  263.     mov    word ptr stack8+2,ax    ; save current stack
  264.     mov    word ptr stack8,sp
  265.     mov    ax,word ptr tcpstack+2    ; get TCP stack seg
  266.     mov    ss,ax            ; set to TCP stack
  267.     mov    sp,word ptr tcpstack
  268.     sti                ; restart interrupts
  269.     call    _int8tick        ; read some packets
  270.     mov    ax,word ptr stack8+2    ; get original stack seg
  271.     cli
  272.     mov    ss,ax
  273.     mov    sp,word ptr stack8
  274.     sti
  275.     pop    es
  276.     pop    di
  277.     pop    si
  278.     pop    dx
  279.     pop    cx
  280.     pop    bx
  281.     pop    bp
  282.     and    tcpflag,not 2        ; finished our running of TCP code
  283. ourtim2:pop    ax
  284.     pop    ds
  285.     iret
  286. ourtimer endp
  287.  
  288. ; This routine is invoked from outside by Int 14h. Enter with the caller's
  289. ; registers but our CS. Switch stacks and data segments.
  290. ; This version supports 3Com BAPI calls and does the near/far stuff via
  291. ; a local buffer.
  292. ourserial proc    near            ; Interrupt 14h service routine
  293.     assume    ds:DGROUP
  294.     push    ds
  295.     push    ax
  296.     mov    ax,dgroup        ; set addressibility to our dgroup
  297.     mov    ds,ax
  298.     pop    ax
  299.     test    tcpflag,2        ; is Int 8 running TCP?
  300.     jz    ourser8            ; z = no
  301.     mov    ah,1            ; say no char written
  302.     xor    cx,cx            ; chars written
  303.     pop    ds
  304.     iret
  305.  
  306. ourser8:or    tcpflag,1        ; say we are running TCP
  307.     push    es            ; save regs on the user's stack
  308.     push    di
  309.     push    si
  310.     push    dx
  311.     push    bx
  312.     push    bp
  313.     push    ax
  314.     mov    ax,dgroup        ; set addressibility to our dgroup
  315.     mov    ds,ax
  316.     pop    ax
  317.     mov    kstack,sp        ; remember caller's stack now
  318.     mov    sp,word ptr tcpstack    ; move to our TCP stack
  319.     mov    word ptr userbuf,bx    ; remember caller's es:bx
  320.     mov    word ptr userbuf+2,es
  321.     mov    _bapireq,cx        ; requested char count to TCP code
  322.     mov    _bapiret,0        ; init returned CX char count
  323.     mov    opcode,ah        ; remember operation for return proc
  324.     cmp    ah,bapihere        ; presence check?
  325.     jne    ourser6            ; ne = no
  326.     mov    ax,0af01h        ; return this value
  327.     jmp    ourser4            ; done
  328.  
  329. ourser6:
  330.     cmp    ah,bapiwrit        ; BAPI write?
  331.     jne    ourser2            ; ne = no
  332.     push    ax
  333.     push    cx
  334.     push    es
  335.     push    ds
  336.     mov    di,offset DGROUP:_bapibuf ; where it goes
  337.     mov    si,bx            ; es:bx, whence it comes
  338.     mov    bx,es
  339.     mov    ax,ds
  340.     mov    es,ax
  341.     mov    ds,bx
  342.     cld
  343.     cmp    cx,buflen        ; largest block i/o we allow here
  344.     jbe    ourser1            ; be = ok
  345.     mov    cx,buflen        ; truncate the request
  346. ourser1:shr    cx,1
  347.     jnc    ourser1a
  348.     movsb
  349. ourser1a:rep    movsw            ; copy their buffer to ours
  350.     pop    ds
  351.     pop    es
  352.     pop    cx
  353.     pop    ax
  354. ourser2:cmp    ah,bapiread        ; read?
  355.     jne    ourser3            ; ne = no
  356.     cmp    _msgcnt,0        ; any outstanding msgs from TCP?
  357.     je    ourser3            ; e = no msgs
  358.     call    oursmsg            ; send back the msgs instead
  359.     jmp    short ourser4        ; ax has status of ok
  360. ourser3:sti                ; let other ints happen
  361.     mov    bx,dgroup        ; set up es to dgroup too
  362.     mov    es,bx            ; bx is not needed at this time
  363.     xchg    ah,al            ; put function code in al
  364.     xor    ah,ah
  365.     push    ax            ; setup call frame
  366.  
  367.     call    _int14handler        ; a near call, _int14handler(ax)
  368.  
  369.     cli                ; reg ax has return status
  370.     add    sp,2            ; clean stack
  371.     mov    cx,dgroup        ; safety check, not really needed
  372.     mov    ds,cx
  373.     mov    cx,_bapiret        ; count of chars returned
  374.     cmp    opcode,bapiread        ; BAPI read?
  375.     jne    ourser4            ; ne = no
  376.     jcxz    ourser4            ; z = nothing to copy
  377.     push    ax
  378.     push    cx
  379.     mov    si,offset DGROUP:_bapibuf ; whence it comes
  380.     mov    di,word ptr userbuf    ; where it goes
  381.     mov    ax,word ptr userbuf+2    ; segment
  382.     mov    es,ax
  383.     cld
  384.     shr    cx,1
  385.     jnc    ourser3a
  386.     movsb
  387. ourser3a:rep    movsw            ; copy our buffer to theirs
  388.     pop    cx            ; return count in cx
  389.     pop    ax            ; return result code in ah, cnt in cx
  390. ourser4:clc                ; assume success
  391.     xchg    ah,al            ; put return status in ah
  392.     xor    al,al
  393.     cmp    ah,3            ; serious error status?
  394.     jb    ourserx            ; b = no, zero is success
  395.     stc                ; set carry too
  396. ourserx:mov    sp,kstack         ; move to caller's stack
  397.     and    tcpflag,not 1        ; say we are not running TCP
  398.     pop    bp
  399.     pop    bx
  400.     pop    dx
  401.     pop    si
  402.     pop    di
  403.     pop    es
  404.     pop    ds
  405.     iret                ; AX and CX are changed as returns
  406. ourserial endp
  407.  
  408. oursmsg    proc    near
  409.     mov    cx,_msgcnt
  410.     jcxz    ourser3            ; z = no msgs
  411.     cmp    cx,_bapireq        ; longer than request?
  412.     jbe    oursmsg1        ; be = no
  413.     mov    cx,_bapireq        ; do this much now
  414. oursmsg1:push    cx
  415.     mov    si,offset DGROUP:_msgbuf ; whence it comes
  416.     mov    di,word ptr userbuf    ; where it goes
  417.     mov    ax,word ptr userbuf+2    ; segment
  418.     mov    es,ax
  419.     cld
  420.     rep    movsb            ; copy our buffer to theirs
  421.     pop    cx            ; return count in cx
  422.     mov    _bapiret,cx        ; return count to user
  423.     sub    _msgcnt,cx        ; deduct chars relayed
  424.     cmp    _msgcnt,0        ; examine remainder
  425.     je    oursmsg3        ; e = none
  426.     mov    ax,_msgcnt        ; count
  427.     push    ax
  428.     mov    ax,offset DGROUP:_msgbuf
  429.     push    ax            ; destination
  430.     add    ax,_msgcnt        ; source
  431.     push    ax
  432.     call    _bcopy            ; copy to beginning of buffer
  433.     add    sp,6            ; clean stack
  434. oursmsg3:mov    ax,0            ; return status of success
  435.     ret
  436. oursmsg    endp
  437.  
  438.  
  439. ; tcpaddress db    '127.0.0.1',(32-($-tcpaddress)) dup (0),0
  440. ; tcpsubnet  db    '255.255.255.0',(32-($-tcpsubnet)) dup (0),0
  441. ; tcpdomain  db    'loopback',(32-($-tcpdomain)) dup (0),0
  442. ; tcpgateway db    '127.0.0.1',(32-($-tcpgateway)) dup (0),0
  443. ; tcpprimens db    '127.0.0.1',(32-($-tcpprimens)) dup (0),0
  444. ; tcpsecondns db '127.0.0.1',(32-($-tcpsecondns)) dup (0),0
  445. ; tcphost db    (32-($-tcphost)) dup (0),0
  446. ; tcpbcast db    0ffh
  447. ; 
  448. ; tcpdata dw    offset tcpaddress ; externally visible far pointers
  449. ;     dw    offset tcpsubnet
  450. ;     dw    offset tcpdomain
  451. ;     dw    offset tcpgateway
  452. ;     dw    offset tcpprimens
  453. ;     dw    offset tcpsecondns
  454. ;    dw    offset tcphost
  455. ;    dw    offset tcpbcast
  456.  
  457.     public    ktcpstart
  458. ktcpstart proc    far
  459.     ASSUME    DS:DATA, ES:DGROUP
  460.     push    es            ; save regs on main Kermit stack
  461.     push    ds
  462.     push    di
  463.     push    si
  464.     push    dx
  465.     push    cx
  466.     push    bx
  467.     push    bp
  468.     mov    ax,DGROUP
  469.     mov    es,ax            ; destination is the TCP module
  470.     cld
  471.     mov    tcpdata,bx        ; store offset of Kermit data block
  472.     mov    si,[bx]            ; get offset of our IP address
  473.     mov    di,offset DGROUP:_kmyip    ; our storage slot
  474.     mov    cx,16            ; max bytes
  475. start5:    lodsb
  476.     stosb
  477.     or    al,al
  478.     loopne    start5            ; copy IP address string, asciiz
  479.     xor    al,al            ; extra terminator
  480.     stosb
  481.     mov    si,[bx+2]        ; get offset in Kermit
  482.     mov    di,offset DGROUP:_knetmask
  483.     mov    cx,16
  484. start6:    lodsb
  485.     stosb
  486.     or    al,al
  487.     loopne    start6
  488.     xor    al,al
  489.     stosb
  490.     mov    si,[bx+4]            ; get offset in Kermit
  491.     mov    di,offset DGROUP:_kdomain
  492.     mov    cx,32
  493. start7:    lodsb
  494.     stosb
  495.     or    al,al
  496.     loopne    start7
  497.     xor    al,al
  498.     stosb
  499.     mov    si,[bx+6]            ; get offset in Kermit
  500.     mov    di,offset DGROUP:_kgateway
  501.     mov    cx,32
  502. start8:    lodsb
  503.     stosb
  504.     or    al,al
  505.     loopne    start8
  506.     xor    al,al
  507.     stosb
  508.     mov    si,[bx+8]            ; get offset in Kermit
  509.     mov    di,offset DGROUP:_kns1
  510.     mov    cx,32
  511. start9:    lodsb
  512.     stosb
  513.     or    al,al
  514.     loopne    start9
  515.     xor    al,al
  516.     stosb
  517.     mov    si,[bx+10]            ; get offset in Kermit
  518.     mov    di,offset DGROUP:_kns2
  519.     mov    cx,32
  520. start10:lodsb
  521.     stosb
  522.     or    al,al
  523.     loopne    start10
  524.     xor    al,al
  525.     stosb
  526.     mov    si,[bx+12]            ; get offset in Kermit
  527.     mov    di,offset DGROUP:_khost
  528.     mov    cx,32
  529. start11:lodsb
  530.     stosb
  531.     or    al,al
  532.     loopne    start11
  533.     xor    al,al
  534.     stosb
  535.     mov    si,[bx+14]            ; broadcast byte address
  536.     mov    di,offset DGROUP:_kbcast
  537.     mov    cx,32
  538. start12:lodsb
  539.     stosb
  540.     or    al,al
  541.     loopne    start12
  542.     xor    al,al
  543.     stosb
  544.     mov    es:_display_mode,0    ; presume quiet screen
  545.     test    flags.remflg,dquiet    ; quiet display mode?
  546.     jnz    start13            ; nz = yes. Don't write to screen
  547.     inc    es:_display_mode    ; say can write to screen
  548. start13:mov    bx,tcptos        ; top of stack for tcp code
  549.  
  550.     assume    ds:DGROUP, ES:NOTHING
  551.     
  552.     mov    ax,dgroup        ; set addressibility to our dgroup
  553.     mov    ds,ax
  554.     mov    es,ax
  555.     mov    word ptr tcpstack+2,ax    ; set TCP stack seg
  556.     mov    word ptr kstack,sp    ; store Kermit's stack ptr
  557.     mov    sp,bx            ; new TCP stack pointer, DGROUP based
  558.     mov    bp,sp            ; preset this as insurance
  559.     or    tcpflag,1        ; say this is running TCP code
  560.     call    _main            ; call the C code
  561.     and    tcpflag,not 1        ; finished running tcp code
  562.     mov    sp,word ptr kstack    ; restore for Kermit's main stack
  563.     pop    bp            ; restore regs, Kermit's main stack
  564.     pop    bx
  565.     pop    cx
  566.     pop    dx
  567.     pop    si
  568.     pop    di
  569.     pop    ds
  570.     pop    es
  571.     ret                ; return to caller
  572. ktcpstart endp
  573.  
  574.     public    ktcpstop
  575. ktcpstop proc    far
  576.     assume    ds:dgroup, es:nothing
  577.     push    es            ; save regs on the user's stack
  578.     push    ds
  579.     push    di
  580.     push    si
  581.     push    dx
  582.     push    cx
  583.     push    bx
  584.     push    bp
  585.     mov    ax,dgroup        ; set addressibility to our dgroup
  586.     mov    ds,ax
  587.     mov    kstack,sp        ; remember Kermit's main sp
  588.     or    tcpflag,1        ; say we are running TCP code
  589.     mov    ax,word ptr tcpstack    ; set sp to TCP sp
  590.     mov    sp,ax
  591.     mov    bp,sp            ; preset this as insurance
  592.     push    ds
  593.     pop    es
  594.     xor    ax,ax
  595.     push    ax            ; exit(0) setup
  596.     call    _exit
  597.     add    sp,2            ; returns status in AX
  598.     mov    tempax,ax
  599.     mov    ax,word ptr tcpstack    ; set sp to TCP sp again
  600.     mov    sp,ax
  601.     mov    bp,sp            ; preset this as insurance
  602.     call    _pkt_release        ; do this as insurance
  603.     mov    ax,tempax        ; regain status
  604.     push    ax
  605.     call    unhookvect        ; ditto
  606.     pop    ax
  607.     mov    tcpflag,0        ; no one is running the TCP code
  608.     mov    sp,kstack
  609.     pop    bp            ; restore regs, Kermit's main stack
  610.     pop    bx
  611.     pop    cx
  612.     pop    dx
  613.     pop    si
  614.     pop    di
  615.     pop    ds
  616.     pop    es
  617.     ret                ; return to caller
  618. ktcpstop endp
  619.  
  620.     public    _readback
  621. _readback proc    near
  622.     assume    ds:dgroup, es:dgroup
  623.     push    bp
  624.     mov    bp,sp
  625.     push    si
  626.     push    di
  627.     push    es
  628.     mov    ax,data
  629.     mov    es,ax
  630.     mov    si,offset dgroup:_kmyip
  631.     push    si
  632.     push    si
  633.     call    _strlen                ; get length of string
  634.     add    sp,2
  635.     pop    si
  636.     mov    di,tcpdata            ; copy to Kermit main body
  637.     mov    di,es:[di]            ; offset of the string
  638.     mov    cx,ax
  639.     cld
  640.     rep    movsb
  641.     xor    al,al
  642.     stosb                    ; terminator
  643.     mov    si,offset dgroup:_knetmask
  644.     mov    di,tcpdata
  645.     mov    di,es:[di+2]
  646.     mov    cx,17
  647.     rep    movsb
  648.     stosb                    ; terminator
  649.     mov    si,offset dgroup:_kgateway
  650.     mov    di,tcpdata
  651.     mov    di,es:[di+6]
  652.     mov    cx,17
  653.     rep    movsb
  654.     stosb                    ; terminator
  655.     mov    si,offset dgroup:_kns1
  656.     mov    di,tcpdata
  657.     mov    di,es:[di+8]
  658.     mov    cx,17
  659.     rep    movsb
  660.     stosb                    ; terminator
  661.     mov    si,offset dgroup:_kns2
  662.     mov    di,tcpdata
  663.     mov    di,es:[di+10]
  664.     mov    cx,17
  665.     rep    movsb
  666.     stosb                    ; terminator
  667.     pop    es
  668.     pop    si
  669.     pop    di
  670.     pop    bp
  671.     ret
  672. _readback endp
  673.  
  674. ; Track Telnet echo variable (0 do not do local echo) into terminal emulator
  675. ; and Kermit main body. Call this each time Telnet options change echo.
  676.     public    _kecho
  677. _kecho    proc    near
  678.     assume    ds:data, es:dgroup
  679.     push    bp
  680.     mov    bp,sp
  681.     push    ds
  682.     push    es
  683.     push    si
  684.     push    ax
  685.     mov    ax,data            ; Kermit main data segment
  686.     mov    ds,ax
  687.     mov    ax,dgroup
  688.     mov    es,ax
  689.     mov    ax,[bp+4+0]        ; get Telnet _echo variable
  690.     and    yflags,not lclecho    ; assume no local echo in emulator
  691.     or    al,al            ; Telnet local echo is off?
  692.     jz    kecho1            ; z = yes
  693.     mov    al,lclecho        ; lclecho flag for emulator
  694. kecho1:    or    yflags,al        ; set terminal emulator
  695.     mov    si,portval
  696.     mov    [si].ecoflg,al        ; set mainline SET echo flag
  697.     pop    ax
  698.     pop    si
  699.     pop    es
  700.     pop    ds
  701.     pop    bp
  702.     ret
  703. _kecho    endp
  704. _TEXT    ends
  705.         end
  706.  
  707.